package rainbowPackage;

//import javafx.scene.paint.Paint.*;
import javafx.scene.paint.Color;

public class RainbowPattern2D //For All Rainbow Patterns To Be Displayed With RainbowSoftColor.java Functions Determining Rainbow/Custom Colors Variation
{//Initializers
	public double[] RGB = {0,0,0}, ARGB = {0,0,0,1};
	public Color FXColor;
	public Color[] fxColorArray = { FXColor.PINK, FXColor.SKYBLUE };
	public double ColorBeingChecked = 0, OpacityBeingChecked = 1, sliderValue = 0;
	public RainbowSoftColor color = new RainbowSoftColor( new double[]{0,0,0,1} );

	public RainbowPattern2D( Color FXColor )//Creates Class And Sets Color With JavaFX Color Class //
	{
		this.FXColor = FXColor;
		this.color = new RainbowSoftColor( FXColor );
		this.RGB = new double[] { FXColor.getRed() * 255, FXColor.getGreen() * 255, FXColor.getBlue() * 255 };
		this.ARGB = new double[] { FXColor.getRed() * 255, FXColor.getGreen() * 255, FXColor.getBlue() * 255, FXColor.getOpacity() };
	}
	public RainbowPattern2D( double[] ARGB )//Creates Class And Sets Color With ARGB //
	{
		for  (int z = 0; z <= 2; z++)
		{
			this.RGB[z] = ColorValueFitter(ARGB[z]);
			this.ARGB[z] = ColorValueFitter(ARGB[z]);
		}
		if ( ARGB.length == 3 )
		{
			this.ARGB = new double[4];
			for  (int z = 0; z <= 2; z++)
				this.ARGB[z] = ColorValueFitter(RGB[z]);
			ARGB[3] = 1;
		}
		else
			this.ARGB[3] = OpacityValueFitter(ARGB[3]);
		this.color = new RainbowSoftColor( ARGB );
		this.FXColor = color.ToFXColor();
	}
	public RainbowPattern2D()//Creates Class And Sets Color To Opake Black //
	{
		this.RGB = new double[]{0,0,0};
		this.ARGB = new double[]{0,0,0,1};
		this.color = new RainbowSoftColor( RGB );
		this.FXColor = color.ToFXColor();
	}
	public Color ToFXColor ()//Returns Color In JavaF
	{
		this.FXColor = color.ToFXColor();
		return FXColor;
	}
	public Color ToFXColor ( double[] ARGB )//Changes Class To ARGB Value And Returns Color In JavaFX //
	{
		for  (int z = 0; z <= 2; z++)
		{
			this.RGB[z] = ColorValueFitter(ARGB[z]);
			this.ARGB[z] = ColorValueFitter(ARGB[z]);
		}
		if ( ARGB.length == 3 )
		{
			this.ARGB = new double[4];
			for  (int z = 0; z <= 2; z++)
				this.ARGB[z] = ColorValueFitter(RGB[z]);
			ARGB[3] = 1;
		}
		else
			this.ARGB[3] = OpacityValueFitter(ARGB[3]);
		this.color = new RainbowSoftColor( ARGB );
		this.FXColor = color.ToFXColor();
		return FXColor;
	}

	public Object RainbowSoftColorFunction(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, RainbowSoftColor ColorBefore, RainbowSoftColor ColorAfter)//Use This To Access ColorSlider{Location/ColorsLength How Much From ColorBefore To ColorAfter} Though This Function //Top Bar At Top In SimpleDiagnosticsClass.java
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		for (int z = 0; z <= 2; z++)
		{
			RGB[z] = ColorValueFitter( ( (ColorAfter.RGB[z] - ColorBefore.RGB[z]) * sliderValue/ColorsLength + ColorBefore.RGB[z] ) );
			ARGB[z] = ColorValueFitter( RGB[z] );
		}
		ARGB[3] = 1;
		this.color = new RainbowSoftColor( RGB );
		this.FXColor = color.ToFXColor();
		return color;
	}

	public Object SimpleRainbow(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat)//Make Simple Rainbow In The Same Fashion As Above, ColorsLength Length Of Rainbow Respective To Location //Choose ColorsLength To Be Same As LengthOfRepeat For Best Rainbow //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowFunction(Math.abs( ColorsLength ), sliderValue);//1st Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbow(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations)//Same As Above True And Not Mentioned Anymore BrightnessMultiplier From 0{Black}-1{Same-Color} How Dim, 1-255 How Bright To White. Graduations How Many Different Unadjusted Bars For Each Color //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//2nd Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbow(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, boolean Adjusted )//Now Adjusted To Look Better At The Cost Of Speed Gradations Choice //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftColorRainbowFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//3rd Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftColorRainbowFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//4th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbowReverse(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat)//Reverse Color Directions As Rainbow With Green Flipped With Hot Pink //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowFunctionReverse(Math.abs( ColorsLength ), sliderValue);//5th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbowReverse(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations )//Same As Above But Reversed //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowFunctionReverseAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//6th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbowReverse(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, boolean Adjusted )//Same Adjustment //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftColorRainbowFunctionReverseAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//7th Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftColorRainbowFunctionReverseUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations);//8th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double[][] RGBcolorArray)//Put Any Amount Of Custom Colors In RGB Format Not ARGB As Opacity Variabled Funtions And Transparency Slider Can Be Implimented Seperatly For That //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsLength ), sliderValue, RGBcolorArray);//9th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, Color[] FXcolorArray)//For Colors In JavaFX //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsLength ), sliderValue, FXcolorArray);//10th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, double[][] ARGBcolorArray )//Things Should Follow For The Rest Of The Simple Linear Rainbows Until Opacity //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftCustomColorFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, ARGBcolorArray);//11th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, double[][] ARGBcolorArray, boolean Adjusted ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftCustomColorFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, ARGBcolorArray);//12th Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftCustomColorFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, ARGBcolorArray);//13th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, Color[] FXcolorArray ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		//System.out.println( "2D FXcolors Brightnesses" + FXcolorArray[0].getBrightness() + FXcolorArray[1].getBrightness() + FXcolorArray[2].getBrightness() + FXcolorArray[3].getBrightness() + FXcolorArray[4].getBrightness() + FXcolorArray[5].getBrightness() );
		this.color.RainbowSoftCustomColorFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray);//14th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, Color[] FXcolorArray, boolean Adjusted ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		//System.out.println( "2D FXcolors Brightnesses" + FXcolorArray[0].getBrightness() + FXcolorArray[1].getBrightness() + FXcolorArray[2].getBrightness() + FXcolorArray[3].getBrightness() + FXcolorArray[4].getBrightness() + FXcolorArray[5].getBrightness() );
		if ( Adjusted )
			this.color.RainbowSoftCustomColorFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray);//15th Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftCustomColorFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray);//16th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbow(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter )//Same As Above Except Opacity Goes From OpacityBefore To OpacityAfter From Red To Purple And For Reverse Purple To Pink To Red With Rainbow Colors In-between
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//17th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbow(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, boolean Adjusted, double OpacityBefore, double OpacityAfter ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//18th Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftColorRainbowTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//19th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbowReverse(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//20th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleRainbowReverse(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, boolean Adjusted, double OpacityBefore, double OpacityAfter ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//21st Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftColorRainbowTransparencyFunctionReverseUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter);//22nd Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, double[][] RGBcolorArray, boolean Adjusted, double OpacityBefore, double OpacityAfter ) //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, RGBcolorArray, OpacityBefore, OpacityAfter);//23rd Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, RGBcolorArray, OpacityBefore, OpacityAfter);//24th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object SimpleCustomColor(double ColorsLength, double Location, double MarkerInLength, double LengthOfRepeat, double BrightnessMultiplyer, int Gradations, Color[] FXcolorArray, boolean Adjusted, double OpacityBefore, double OpacityAfter )//Same Follows From Above To Here But Not The Next Function Which Is Not A Linear Rainbow //
	{
		sliderValue = SliderFormulate( ColorsLength, MarkerInLength, Location, LengthOfRepeat );
		if ( Adjusted )
			this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter);//25th Square In SimpleDiagnosticsClass.java
		else
			this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter);//26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}

	public Object RainbowDiskVaryated(double ColorsLength, double Location, double x, double y, double RadiusOfRepeat, boolean Reversed)//Choose ColorsLength To Be Same As RadiusOfRepeat Of Rainbow Disk Line With x & y Precentered Before Accessing This Function And Location Is The Connection To The xSlider Time Changing Variable
	{//With NonPrePost Color Sliders; Also Looks Cool When Into RainbowSoftColorRainbowFunction -> ColorsLength / 6 //Also Looks Cool When RadiusOfRepeat In Here Is Halfed //Also Looks Cool When While < & > Is Swapped //Below Add - Location; and No sliderValue + ColorsLength For Cool Defects
		sliderValue = SliderFormulate( ColorsLength, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ), Location, RadiusOfRepeat );//Above Provides NonAligned RadiusOfRepeat/ColorsLength != 1 For Shrinked[>1] And Abridged Rainbow[<1]
		if ( Reversed )
			this.color.RainbowSoftColorRainbowFunctionReverse( ColorsLength, sliderValue ); //
		else
			this.color.RainbowSoftColorRainbowFunction( ColorsLength, sliderValue ); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowDiskGradated(double ColorsLength, double Location, double x, double y, double RadiusOfRepeat, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Except Gradated Un/Adjusted With Opacity Changes
	{
		sliderValue = SliderFormulate( ColorsLength, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ), Location, RadiusOfRepeat );
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowDiskVaryated(double ColorsLength, double Location, double x, double y, double RadiusOfRepeat, Color[] FXcolorArray, boolean Reversed)//Same As Above Except With Any Amount Of Custom Colors And Not All Accouchriments As Below
	{
		sliderValue = SliderFormulate( ColorsLength, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ), Location, RadiusOfRepeat );
		if (Reversed)
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsLength ), sliderValue, CustomColorsReverser(FXcolorArray)); //
		else
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsLength ), sliderValue, FXcolorArray); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowDiskGradated(double ColorsLength, double Location, double x, double y, double RadiusOfRepeat, Color[] FXcolorArray, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Super Function For Any Custom Colors Disks Which Is Last Rainbow Disk Function
	{
		sliderValue = SliderFormulate( ColorsLength, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ), Location, RadiusOfRepeat );
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsLength ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray,  OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}

	public Object RainbowClockVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, boolean Reversed)//NumberOfClock Hands Will Provide A Disjointed Series Of Rainbow Triangles, ClockHandDisplacement = Math.PI For Normal Clock//Choose ColorsFactor To Be Same As FactorOfRepeat Of Rainbow Clock With x & y Precentered Before Accessing This Function And Location Is The Connection To The xSlider Time Changing Variable //, double OneLessThanTheNumberOfClockHands, double ClockHandDisplacement
	{
		sliderValue = SliderFormulate( ColorsFactor, Math.atan2(x, y), Location, FactorOfRepeat );
		if ( Reversed )
			this.color.RainbowSoftColorRainbowFunctionReverse(Math.abs( ColorsFactor ), sliderValue); //
		else
			this.color.RainbowSoftColorRainbowFunction(Math.abs( ColorsFactor ), sliderValue); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowClockGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double OneLessThanTheNumberOfClockHands, double ClockHandDisplacement, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Except Gradated Un/Adjusted With Opacity Changes
	{//(NotNeeded)Longness Definatly Needed sliderValue = SliderFormulate( ColorsFactor, ( 180 - ClockHandDisplacement * ( Math.PI - 3.14159265358979 ) / ( Math.PI - 3.1415926535897 ) * ( Math.PI - 3.141592653589 ) / ( Math.PI - 3.14159265358 ) * ( Math.PI - 3.1415926535 ) / ( Math.PI - 3.141592653 ) * ( Math.PI - 3.14159265 ) / ( Math.PI - 3.1415926 ) * ( Math.PI - 3.141592 ) / ( Math.PI - 3.14159 ) * ( Math.PI - 3.1415 ) / ( Math.PI - 3.141 ) * ( Math.PI - 3.14 ) / ( Math.PI - 3.1 ) * ( Math.PI - 3 ) ) * ( Math.atan2(x, y) + ClockHandDisplacement ) / OneLessThanTheNumberOfClockHands, Location, FactorOfRepeat );//Math.PI = 3.141592653589793 Points And Segments May Be A Key To Unraveling Pi In This Situation
		//(NotNeeded)sliderValue = SliderFormulate( ColorsFactor, ( 180 - 10/* - ClockHandDisplacement * ( Math.PI - 3.14159265358979 ) / ( Math.PI - 3.1415926535897 ) * ( Math.PI - 3.141592653589 ) / ( Math.PI - 3.14159265358 ) * ( Math.PI - 3.1415926535 ) / ( Math.PI - 3.141592653 ) * ( Math.PI - 3.14159265 ) / ( Math.PI - 3.1415926 ) * ( Math.PI - 3.141592 ) / ( Math.PI - 3.14159 ) * ( Math.PI - 3.1415 ) / ( Math.PI - 3.141 ) * ( Math.PI - 3.14 ) / ( Math.PI - 3.1 ) * ( Math.PI - 3 ) */ ) * ( Math.atan2(x, y) + ClockHandDisplacement ) / OneLessThanTheNumberOfClockHands, Location, FactorOfRepeat );//Math.PI = 3.141592653589793 Points And Segments May Be A Key To Unraveling Pi In This Situation
		sliderValue = SliderFormulate( ColorsFactor, ( 180 - ClockHandDisplacement * ( Math.PI - 3.14159265358979 ) / ( Math.PI - 3.1415926535897 ) * ( Math.PI - 3.141592653589 ) / ( Math.PI - 3.14159265358 ) * ( Math.PI - 3.1415926535 ) / ( Math.PI - 3.141592653 ) * ( Math.PI - 3.14159265 ) / ( Math.PI - 3.1415926 ) * ( Math.PI - 3.141592 ) / ( Math.PI - 3.14159 ) * ( Math.PI - 3.1415 ) / ( Math.PI - 3.141 ) * ( Math.PI - 3.14 ) / ( Math.PI - 3.1 ) * ( Math.PI - 3 ) ) * ( Math.atan2(x, y) + ClockHandDisplacement ) / OneLessThanTheNumberOfClockHands, Location, FactorOfRepeat );//Math.PI = 3.141592653589793 Points And Segments May Be A Key To Unraveling Pi In This Situation
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowClockVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, Color[] FXcolorArray, double OneLessThanTheNumberOfClockHands, double ClockHandDisplacement, boolean Reversed )//Same As Above Except With Any Amount Of Custom Colors And Not All Accouchriments As Below
	{
		sliderValue = SliderFormulate( ColorsFactor, ( 180 /* - ( 360 / ( OneLessThanTheNumberOfClockHands + 1) ) * ( Math.PI - 3 ) */ /* * ( Math.PI - 3.14159265358979 ) / ( Math.PI - 3.1415926535897 ) * ( Math.PI - 3.141592653589 ) / ( Math.PI - 3.14159265358 ) * ( Math.PI - 3.1415926535 ) / ( Math.PI - 3.141592653 ) * ( Math.PI - 3.14159265 ) / ( Math.PI - 3.1415926 ) * ( Math.PI - 3.141592 ) / ( Math.PI - 3.14159 ) * ( Math.PI - 3.1415 ) / ( Math.PI - 3.141 ) * ( Math.PI - 3.14 ) / ( Math.PI - 3.1 ) * ( Math.PI - 3 ) */ ) * ( Math.atan2(x, y) + ClockHandDisplacement ) / OneLessThanTheNumberOfClockHands, Location, FactorOfRepeat );//Math.PI = 3.141592653589793 Points And Segments May Be A Key To Unraveling Pi In This Situation
		if (Reversed)
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, CustomColorsReverser(FXcolorArray)); //
		else
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, FXcolorArray); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowClockGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, Color[] FXcolorArray, double OneLessThanTheNumberOfClockHands, double ClockHandDisplacement, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Super Function For Any Custom Colors Clocks Which Is Last Rainbow Disk Function
	{
		sliderValue = SliderFormulate( ColorsFactor, ( 180 - ClockHandDisplacement * ( Math.PI - 3.14159265358979 ) / ( Math.PI - 3.1415926535897 ) * ( Math.PI - 3.141592653589 ) / ( Math.PI - 3.14159265358 ) * ( Math.PI - 3.1415926535 ) / ( Math.PI - 3.141592653 ) * ( Math.PI - 3.14159265 ) / ( Math.PI - 3.1415926 ) * ( Math.PI - 3.141592 ) / ( Math.PI - 3.14159 ) * ( Math.PI - 3.1415 ) / ( Math.PI - 3.141 ) * ( Math.PI - 3.14 ) / ( Math.PI - 3.1 ) * ( Math.PI - 3 ) ) * ( Math.atan2(x, y) + ClockHandDisplacement ) / OneLessThanTheNumberOfClockHands, Location, FactorOfRepeat );//Math.PI = 3.141592653589793 Points And Segments May Be A Key To Unraveling Pi In This Situation
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray,  OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}

	//Search For Or Put In Accessing Class: //pattern2D.RainbowSpiralVaryated( fullAngle, xSlider, ( x - HalfedDim.width ) / 3., ( y - HalfedDim.height ) / 3., fullAngle, 24.6, 1, halfSreenDiagionalLength, false );//For Proper Rainbow Hypnosis Spiral
	//pattern2D.RainbowSpiralVaryated( fullAngle, xSlider, ( x - HalfedDim.width ) / 10., ( y - HalfedDim.height ) / 10., fullAngle, 144, 10, halfSreenDiagionalLength, false );//For Proper Rainbow Rainbow Shrunken
	//pattern2D.RainbowSpiralVaryated( fullAngle * 6, xSlider * 6, ( x - HalfedDim.width ) / 6., ( y - HalfedDim.height ) / 6., fullAngle, 88.8, 4, halfSreenDiagionalLength, false );//For Segment View
	//pattern2D.RainbowSpiralVaryated( fullAngle, xSlider * 3, ( x - HalfedDim.width ) / 6., ( y - HalfedDim.height ) / 6., fullAngle * 3, 66.6, 3, halfSreenDiagionalLength, false );//For View Of More Length Than 1 Segment, Values Must Be Mulitples Of Eachother Somehow 3 In This Instance
	//pattern2D.RainbowSpiralVaryated( fullAngle, xSlider, ( x - HalfedDim.width ) / 1., ( y - HalfedDim.height ) / 1., fullAngle, 999, 1680, halfSreenDiagionalLength, false );//For Proper Rainbow PsychaHypnotic
	public Object RainbowSpiralVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double SpiralFactor, double NumberOfSpirals, double HalfSreenDiagionalLength, boolean Reversed)//SpiralFactor = 24.6 For HypnosisSpiral NumberOfSpirals = 1 x&y/3., For More Sprialing Increase Spiral Factor, For Ninja Shrunken; SpiralFactor = 88.8 & NumberOfSpirals = 10 x&y/10.,  For Universe Generator; SpiralFactor = 66.6 & NumberOfSpirals = 4 x&y/6.,, x->y Relative Factoring Causes Warping Effect, Choose ColorsFactor To Be Same As FactorOfRepeat Of Rainbow Clock With x & y Precentered Before Accessing This Function And Location Is The Connection To The xSlider Time Changing Variable
	{//Make Math.pow(Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) Into Math.pow(Math.pow(HalfedDim.width + 1, 2) + Math.pow(HalfedDim.height + 1, 2), 0.5) Or To SpiralFactor For Ghetto Many Rainbow Clocks
		//System.out.println("x: " + x +" y: " + y);
		sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * HalfSreenDiagionalLength, Location, FactorOfRepeat );//sliderValue = SliderFormulate( ColorsFactor, ( Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals ) * FactorOfRepeat, Location, FactorOfRepeat );// For Awesome Psycadelic Experience + //sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * Math.pow( FactorOfRepeat , 2), Location, FactorOfRepeat );//sliderValue = SliderFormulate( ColorsFactor, ( Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * FactorOfRepeat ) * FactorOfRepeat, Location, FactorOfRepeat );
		if ( Reversed )
			this.color.RainbowSoftColorRainbowFunctionReverse( ColorsFactor, sliderValue ); //
		else
			this.color.RainbowSoftColorRainbowFunction( ColorsFactor, sliderValue ); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowSpiralGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double SpiralFactor, double NumberOfSpirals, double HalfSreenDiagionalLength, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Except Gradated Un/Adjusted With Opacity Changes
	{
		sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * HalfSreenDiagionalLength, Location, FactorOfRepeat );
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowSpiralVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double SpiralFactor, double NumberOfSpirals, double HalfSreenDiagionalLength, Color[] FXcolorArray, boolean Reversed )//Same As Above Except With Any Amount Of Custom Colors And Not All Accouchriments As Below
	{
		sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * HalfSreenDiagionalLength, Location, FactorOfRepeat );
		if (Reversed)
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, CustomColorsReverser(FXcolorArray)); //
		else
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, FXcolorArray); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowSpiralGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double SpiralFactor, double NumberOfSpirals, double HalfSreenDiagionalLength, Color[] FXcolorArray, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Super Function For Any Custom Colors Clocks Which Is Last Rainbow Disk Function
	{
		sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ) * SpiralFactor + ( - Math.atan2(x, y) + Math.PI ) * NumberOfSpirals * HalfSreenDiagionalLength, Location, FactorOfRepeat );
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray,  OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowCheapFractalVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, double DimWidth, boolean Reversed)//Choose ColorsFactor To Be Same As FactorOfRepeat Of Rainbow Clock With x & y Precentered Before Accessing This Function And Location Is The Connection To The xSlider Time Changing Variable
	{
		sliderValue = SliderFormulate( ColorsFactor, ( - ( y + 246 * Location ) - ( x + 24 * Location - 2 * DimWidth ) * Math.pow(Location , 1.20) / ( y + 0.5 ) ), Location, FactorOfRepeat );
		if ( Reversed )
			this.color.RainbowSoftColorRainbowFunctionReverse( ColorsFactor, sliderValue ); //
		else
			this.color.RainbowSoftColorRainbowFunction( ColorsFactor, sliderValue ); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowCheapFractalGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Except Gradated Un/Adjusted With Opacity Changes
	{

		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftColorRainbowTransparencyFunctionReverseUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftColorRainbowTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowCheapFractalVaryated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, Color[] FXcolorArray, boolean Reversed )//Same As Above Except With Any Amount Of Custom Colors And Not All Accouchriments As Below
	{
		sliderValue = SliderFormulate( ColorsFactor, ( Math.atan2(x, y) + Math.PI ) * FactorOfRepeat, Location, FactorOfRepeat );
		if (Reversed)
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, CustomColorsReverser(FXcolorArray)); //
		else
			this.color.RainbowSoftCustomColorFunction(Math.abs( ColorsFactor ), sliderValue, FXcolorArray); //
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}
	public Object RainbowCheapFractalGradated(double ColorsFactor, double Location, double x, double y, double FactorOfRepeat, Color[] FXcolorArray, boolean Reversed, double BrightnessMultiplyer, int Gradations, double OpacityBefore, double OpacityAfter, boolean Adjusted )//Same As Above Super Function For Any Custom Colors Clocks Which Is Last Rainbow Disk Function
	{
		sliderValue = SliderFormulate( ColorsFactor, ( Math.atan2(x, y) + Math.PI ) * FactorOfRepeat, Location, FactorOfRepeat );
		if ( Adjusted )
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray, OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		else
			if ( Reversed )
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, CustomColorsReverser(FXcolorArray), OpacityBefore, OpacityAfter); //25th Square In SimpleDiagnosticsClass.java
			else
				this.color.RainbowSoftCustomColorTransparencyFunctionUnAdjusted(Math.abs( ColorsFactor ), sliderValue, BrightnessMultiplyer, Gradations, FXcolorArray,  OpacityBefore, OpacityAfter); //26th Square In SimpleDiagnosticsClass.java
		this.RGB = color.RGB;
		this.ARGB = color.ARGB;
		this.FXColor = color.ToFXColor();
		return color;
	}

	//Build SimpleRainbowPattern2DDiagnosticsClass.java First With Color To Similar Tested In ???27th??? Square In In SimpleDiagnosticsClass.java 3 Horizontal x 9 Vertical Under 3 Bars
	//Formula String At End Of Complex Labeled Objects Instead Of Simple Labeled Objects
	//Formula Solver Which Reads Formula String And Processes Formula Into Location Within Color Interval Or OutPuts Same Location With Console Readout "Formula Not Found, No Formula Used -> Variable Sent Through Formula Processor Without Change."
	//Build ComplexRainbowPattern2DDiagnosticsClass.java Before Testing More Than 1 Formula
	public double SliderFormulate( double ColorsLength, double FormulaValue, double Location, double LengthOfRepeat )
	{//System.out.println("FormulaValue = " + FormulaValue);
		boolean negativeColorsLength = false, negativeLengthOfRepeat = false;
		if ( ColorsLength < 0 )
		{
			negativeColorsLength = true;
			ColorsLength = Math.abs( ColorsLength );
		}
		if ( LengthOfRepeat < 0 )
		{
			negativeLengthOfRepeat = true;
			LengthOfRepeat = Math.abs( LengthOfRepeat );
		}
		FormulaValue = FormulaValue - Location;
		if ( LengthOfRepeat == ColorsLength )
		{
			if ( negativeLengthOfRepeat && negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				if ( FormulaValue - LengthOfRepeat < -LengthOfRepeat / 2 )
					FormulaValue = FormulaValue + 2 * LengthOfRepeat; 
				return FormulaValue - LengthOfRepeat;
			}
			else if ( negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				//System.out.println("LengthOfRepeat - FormulaValue: " + ( LengthOfRepeat - FormulaValue ) );
				return LengthOfRepeat - FormulaValue;
			}
			else if ( negativeLengthOfRepeat )
			{
				//BAD FormulaValue = -FormulaValue;
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
				if ( FormulaValue > LengthOfRepeat / 2 )
				{
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
					return FormulaValue - LengthOfRepeat;
				}
				return -FormulaValue;
			}
			else
			{
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
			}
		}
		else if ( LengthOfRepeat < ColorsLength )	
		{
			if ( negativeLengthOfRepeat && negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				if ( FormulaValue - LengthOfRepeat < -LengthOfRepeat / 2 )
					FormulaValue = FormulaValue + 2 * LengthOfRepeat; 
				return FormulaValue - LengthOfRepeat;
			}
			else if ( negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				//System.out.println("LengthOfRepeat - FormulaValue: " + ( LengthOfRepeat - FormulaValue ) );
				return LengthOfRepeat - FormulaValue;
			}
			else if ( negativeLengthOfRepeat )
			{
				//BAD FormulaValue = -FormulaValue;
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
				if ( FormulaValue > LengthOfRepeat / 2 )
				{
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
					return FormulaValue - LengthOfRepeat;
				}
				return -FormulaValue;
			}
			else
			{
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + ColorsLength;
				while ( FormulaValue > ColorsLength )
					FormulaValue = FormulaValue - ColorsLength;
			}
		}
		else
		{
			while ( FormulaValue < 0 )
				FormulaValue = FormulaValue + LengthOfRepeat;
			while ( FormulaValue > ( LengthOfRepeat + ColorsLength ) / 2  )//Simplified To: ( LengthOfRepeat + ColorsLength ) / 2 ) //Not LengthOfRepeat - ( LengthOfRepeat - ColorsLength ) / 2
				FormulaValue = FormulaValue - LengthOfRepeat;
			if ( negativeLengthOfRepeat && negativeColorsLength )
				return FormulaValue - LengthOfRepeat;
			else if ( negativeColorsLength )
				return LengthOfRepeat - FormulaValue;
			else if ( negativeLengthOfRepeat )
				return -FormulaValue;
		}
		return FormulaValue;
	}
	
	/*	public double SliderFormulate( double ColorsLength, double FormulaValue, double Location, double LengthOfRepeat )
	{//System.out.println("FormulaValue = " + FormulaValue);
		boolean negativeColorsLength = false, negativeLengthOfRepeat = false;
		if ( ColorsLength < 0 )
		{
			negativeColorsLength = true;
			ColorsLength = Math.abs( ColorsLength );
		}
		if ( LengthOfRepeat < 0 )
		{
			negativeLengthOfRepeat = true;
			LengthOfRepeat = Math.abs( LengthOfRepeat );
		}
		FormulaValue = FormulaValue - Location;
		if ( LengthOfRepeat == ColorsLength )
		{
			if ( negativeLengthOfRepeat && negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				if ( LengthOfRepeat - FormulaValue < LengthOfRepeat / 2 )
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
				return FormulaValue - LengthOfRepeat;
			}
			else if ( negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				//System.out.println("LengthOfRepeat - FormulaValue: " + ( LengthOfRepeat - FormulaValue ) );
				return LengthOfRepeat - FormulaValue;
			}
			else if ( negativeLengthOfRepeat )
			{
				//BAD FormulaValue = -FormulaValue;
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
				if ( FormulaValue > LengthOfRepeat / 2 )
				{
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
					return FormulaValue - LengthOfRepeat;
				}
				return -FormulaValue;
			}
			else
			{
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
			}
		}
		else if ( LengthOfRepeat < ColorsLength )	
		{
			if ( negativeLengthOfRepeat && negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				if ( LengthOfRepeat - FormulaValue < LengthOfRepeat / 2 )
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
				return FormulaValue - LengthOfRepeat;
			}
			else if ( negativeColorsLength )
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				//System.out.println("LengthOfRepeat - FormulaValue: " + ( LengthOfRepeat - FormulaValue ) );
				return LengthOfRepeat - FormulaValue;
			}
			else if ( negativeLengthOfRepeat )
			{
				//BAD FormulaValue = -FormulaValue;
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + LengthOfRepeat;
				while ( FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue - LengthOfRepeat;
				if ( FormulaValue > LengthOfRepeat / 2 )
				{
					FormulaValue = FormulaValue + 3 * LengthOfRepeat / 2;
					return FormulaValue - LengthOfRepeat;
				}
				return -FormulaValue;
			}
			else
			{
				while ( FormulaValue < 0 )
					FormulaValue = FormulaValue + ColorsLength;
				while ( FormulaValue > ColorsLength )
					FormulaValue = FormulaValue - ColorsLength;
			}
		}
		else
		{
			while ( FormulaValue < 0 )
				FormulaValue = FormulaValue + LengthOfRepeat;
			while ( FormulaValue > ( LengthOfRepeat + ColorsLength ) / 2  )//Simplified To: ( LengthOfRepeat + ColorsLength ) / 2 ) //Not LengthOfRepeat - ( LengthOfRepeat - ColorsLength ) / 2
				FormulaValue = FormulaValue - LengthOfRepeat;
			if ( negativeLengthOfRepeat && negativeColorsLength )
				return FormulaValue - LengthOfRepeat;
			else if ( negativeColorsLength )
				return LengthOfRepeat - FormulaValue;
			else if ( negativeLengthOfRepeat )
				return -FormulaValue;
		}
		return FormulaValue;
	}
	 */
	
	
	/*if ( negativeLengthOfRepeat && negativeColorsLength )//Makes HalfWay Rainbow
			{
				while ( LengthOfRepeat - FormulaValue < 0 )
					FormulaValue = FormulaValue - LengthOfRepeat;
				while ( LengthOfRepeat - FormulaValue > LengthOfRepeat )
					FormulaValue = FormulaValue + LengthOfRepeat;
				return FormulaValue - LengthOfRepeat;
			}// */
	
	/*boolean negativeColorsLength = false, negativeLengthOfRepeat = false;
		if ( ColorsLength < 0 )
		{
			negativeColorsLength = true;
			ColorsLength = Math.abs( ColorsLength );
		}
		if ( LengthOfRepeat < 0 )
		{
			negativeLengthOfRepeat = true;
			LengthOfRepeat = Math.abs( LengthOfRepeat );
		}
		FormulaValue = FormulaValue - Location;
		if ( LengthOfRepeat == ColorsLength )
		{
			while ( FormulaValue < 0 )
				FormulaValue = FormulaValue + LengthOfRepeat;
			while ( FormulaValue > LengthOfRepeat )
				FormulaValue = FormulaValue - LengthOfRepeat;
			if ( negativeLengthOfRepeat && negativeColorsLength )
				return FormulaValue - LengthOfRepeat;
			else if ( negativeColorsLength )
				return LengthOfRepeat - FormulaValue;
			else if ( negativeLengthOfRepeat )
				return -FormulaValue;
		}
		else if ( LengthOfRepeat < ColorsLength )	
		{
			while ( FormulaValue < 0 )
				FormulaValue = FormulaValue + ColorsLength;
			while ( FormulaValue > ColorsLength )
				FormulaValue = FormulaValue - ColorsLength;
			if ( negativeLengthOfRepeat && negativeColorsLength )
				return FormulaValue - ColorsLength;
			else if ( negativeColorsLength )
				return ColorsLength - FormulaValue;
			else if ( negativeLengthOfRepeat )
				return -FormulaValue;
		}
		else
		{
			while ( FormulaValue < 0 )
				FormulaValue = FormulaValue + LengthOfRepeat;
			while ( FormulaValue > ( LengthOfRepeat + ColorsLength ) / 2  )//Simplified To: ( LengthOfRepeat + ColorsLength ) / 2 ) //Not LengthOfRepeat - ( LengthOfRepeat - ColorsLength ) / 2
				FormulaValue = FormulaValue - LengthOfRepeat;
			if ( negativeLengthOfRepeat && negativeColorsLength )
				return FormulaValue - LengthOfRepeat;
			else if ( negativeColorsLength )
				return LengthOfRepeat - FormulaValue;
			else if ( negativeLengthOfRepeat )
				return -FormulaValue;
		}
		return FormulaValue;// */
	
	/*boolean negativeColorsLength = false, negativeLengthOfRepeat = false;
	if ( ColorsLength < 0 )
		negativeColorsLength = true;
	if ( LengthOfRepeat < 0 )
		negativeLengthOfRepeat = true;
	FormulaValue = FormulaValue - Location;
	if ( Math.abs( LengthOfRepeat ) == Math.abs( ColorsLength ) )
	{
		if ( negativeLengthOfRepeat && negativeColorsLength )
		{
			while ( FormulaValue > 0 )
				FormulaValue = FormulaValue + LengthOfRepeat;
			while ( FormulaValue < LengthOfRepeat )
				FormulaValue = FormulaValue - LengthOfRepeat;
			return Math.abs( FormulaValue );
		}
		else if ( negativeColorsLength )
		{
			while ( FormulaValue > 0 )
				FormulaValue = FormulaValue + ColorsLength;
			while ( FormulaValue < ColorsLength )
				FormulaValue = FormulaValue - ColorsLength;
			return Math.abs( FormulaValue );
		}
		else if ( negativeLengthOfRepeat )
		{
			return -FormulaValue;

		}
		while ( FormulaValue < 0 )
			FormulaValue = FormulaValue + LengthOfRepeat;
		while ( FormulaValue > LengthOfRepeat )
			FormulaValue = FormulaValue - LengthOfRepeat;
	}
	else if ( LengthOfRepeat < ColorsLength )	
	{
		while ( FormulaValue < 0 )
			FormulaValue = FormulaValue + ColorsLength;
		while ( FormulaValue > ColorsLength )
			FormulaValue = FormulaValue - ColorsLength;
		if ( negativeLengthOfRepeat && negativeColorsLength )
			return FormulaValue - ColorsLength;
		else if ( negativeColorsLength )
			return ColorsLength - FormulaValue;
		else if ( negativeLengthOfRepeat )
			return -FormulaValue;
	}
	else
	{
		while ( FormulaValue < 0 )
			FormulaValue = FormulaValue + LengthOfRepeat;
		while ( FormulaValue > ( LengthOfRepeat + ColorsLength ) / 2  )//Simplified To: ( LengthOfRepeat + ColorsLength ) / 2 ) //Not LengthOfRepeat - ( LengthOfRepeat - ColorsLength ) / 2
			FormulaValue = FormulaValue - LengthOfRepeat;
		if ( negativeLengthOfRepeat && negativeColorsLength )
			return FormulaValue - LengthOfRepeat;
		else if ( negativeColorsLength )
			return LengthOfRepeat - FormulaValue;
		else if ( negativeLengthOfRepeat )
			return -FormulaValue;
	}
	return FormulaValue;// */
	
	public Color[] CustomColorsReverser ( Color[] FXcolorArray )//Reverses Custom Colors By Flipping Around Colors Like Rainbow Reversal Without Changing Any Colors Like Green In Rainbow To Pink In Reversed //
	{
		this.fxColorArray = new Color[FXcolorArray.length];
		for (int c = 0; c < FXcolorArray.length; c++)
			fxColorArray[c] = FXcolorArray[ FXcolorArray.length - c - 1 ];
		return fxColorArray;
	}
	public double ColorValueFitter ( double ColorToBeChecked )//Makes Sure Colors Don't Cause Systemic Failures //27th Square In SimpleDiagnosticsClass.java
	{
		this.ColorBeingChecked = Math.abs(ColorToBeChecked);
		while ( ColorBeingChecked > 255)
			this.ColorBeingChecked = ColorBeingChecked - 255;
		return ColorBeingChecked;
	}
	public double OpacityValueFitter ( double OpacityToBeChecked )//Makes Sure Color Opacitys Don't Cause Systemic Failures //28th Square In SimpleDiagnosticsClass.java
	{
		this.OpacityBeingChecked = Math.abs(OpacityToBeChecked);
		while ( OpacityBeingChecked > 1)
			this.OpacityBeingChecked = OpacityBeingChecked - 1;
		return OpacityBeingChecked;
	}
	public void set(double[] ARGB) { this.ARGB = ARGB; this.RGB[0] = ARGB[0]; this.RGB[1] = ARGB[1]; this.RGB[2] = ARGB[2]; this.FXColor = FXColor.rgb( (int)(ColorValueFitter(ARGB[0])), (int)(ColorValueFitter(ARGB[1])), (int)(ColorValueFitter(ARGB[2])), (int)(OpacityValueFitter(ARGB[3])) ); this.color = new RainbowSoftColor( ARGB ); }//Assigns Colors With ARGB //29th Square In SimpleDiagnosticsClass.java
	public void set(Color FXColor) { this.FXColor = FXColor; this.ARGB = new double[] { FXColor.getRed() * 255, FXColor.getGreen() * 255, FXColor.getBlue() * 255, FXColor.getOpacity() }; this.color = new RainbowSoftColor( ARGB ); }//Assigns Colors With FXColor //30th Square In SimpleDiagnosticsClass.java
	public Object get() { return ARGB; }//Returns Always Happen With Variable Output With ARGB Functionality //31st Square In SimpleDiagnosticsClass.java
}


/*while ( radius < colorDisplacement)//For Rainbow Ring
	radius = radius + fullAngle - colorDisplacement;//BAD COMMENT: For Rainbow Ring Take Out - 38
while ( radius > fullAngle )
	radius = radius - fullAngle - colorDisplacement;// */


/*final double chrysanthemumRadius = 60;
double radialVariableDistance = Math.pow(Math.pow( x, 2 ) + Math.pow( y, 2), 0.5);//Comment Out For  Ghetto Many Rainbow Clocks
double angleVariable =  chrysanthemumRadius * ( ( - Math.atan2( x, y ) + Math.PI ) - 6 * Math.PI * Location / ( Math.PI * Math.pow(Math.pow( HalfedDim.width, 2 ) + Math.pow( HalfedDim.height, 2 ), 0.5 ) / 10 ) );//Use For Rainbow Spiral Multiply radialDistance By 10 To Increase The Number Of Spirals
//double radiusVariable = chrysanthemumRadius * ( radialVariableDistance * 24.6 + angleVariable);//radialVariableDistance + colorDisplacement + angle;//Remove + angle And Add xSlider To Make Rainbow Clock
while ( radiusVariable < 0 )//For Rainbow Ring
	radiusVariable = radiusVariable + 2 * Math.PI * chrysanthemumRadius;//BAD COMMENT: For Rainbow Ring Take Out - 38
while ( radiusVariable > 2 * Math.PI * chrysanthemumRadius )
	radiusVariable = radiusVariable - 2 * Math.PI * chrysanthemumRadius;
double colorIntervalVariable = 2 * Math.PI * chrysanthemumRadius / ( FXcolorArray.length - 1 );// USE FOR HYPNOSIS SPIRAL I THINK */
//sliderValue = SliderFormulate( ColorsFactor, Math.pow( Math.pow(x, 2) + Math.pow(y, 2), 0.5 ), Location, FactorOfRepeat );
